home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / js / jspubtd.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  25KB  |  613 lines
  1. /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is Mozilla Communicator client code, released
  17.  * March 31, 1998.
  18.  *
  19.  * The Initial Developer of the Original Code is
  20.  * Netscape Communications Corporation.
  21.  * Portions created by the Initial Developer are Copyright (C) 1998
  22.  * the Initial Developer. All Rights Reserved.
  23.  *
  24.  * Contributor(s):
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. #ifndef jspubtd_h___
  41. #define jspubtd_h___
  42. /*
  43.  * JS public API typedefs.
  44.  */
  45. #include "jstypes.h"
  46. #include "jscompat.h"
  47.  
  48. JS_BEGIN_EXTERN_C
  49.  
  50. /* Scalar typedefs. */
  51. typedef uint16    jschar;
  52. typedef int32     jsint;
  53. typedef uint32    jsuint;
  54. typedef float64   jsdouble;
  55. typedef jsword    jsval;
  56. typedef jsword    jsid;
  57. typedef int32     jsrefcount;   /* PRInt32 if JS_THREADSAFE, see jslock.h */
  58.  
  59. /*
  60.  * Run-time version enumeration.  See jsconfig.h for compile-time counterparts
  61.  * to these values that may be selected by the JS_VERSION macro, and tested by
  62.  * #if expressions.
  63.  */
  64. typedef enum JSVersion {
  65.     JSVERSION_1_0     = 100,
  66.     JSVERSION_1_1     = 110,
  67.     JSVERSION_1_2     = 120,
  68.     JSVERSION_1_3     = 130,
  69.     JSVERSION_1_4     = 140,
  70.     JSVERSION_ECMA_3  = 148,
  71.     JSVERSION_1_5     = 150,
  72.     JSVERSION_1_6     = 160,
  73.     JSVERSION_DEFAULT = 0,
  74.     JSVERSION_UNKNOWN = -1
  75. } JSVersion;
  76.  
  77. #define JSVERSION_IS_ECMA(version) \
  78.     ((version) == JSVERSION_DEFAULT || (version) >= JSVERSION_1_3)
  79.  
  80. /* Result of typeof operator enumeration. */
  81. typedef enum JSType {
  82.     JSTYPE_VOID,                /* undefined */
  83.     JSTYPE_OBJECT,              /* object */
  84.     JSTYPE_FUNCTION,            /* function */
  85.     JSTYPE_STRING,              /* string */
  86.     JSTYPE_NUMBER,              /* number */
  87.     JSTYPE_BOOLEAN,             /* boolean */
  88.     JSTYPE_NULL,                /* null */
  89.     JSTYPE_XML,                 /* xml object */
  90.     JSTYPE_LIMIT
  91. } JSType;
  92.  
  93. /* JSObjectOps.checkAccess mode enumeration. */
  94. typedef enum JSAccessMode {
  95.     JSACC_PROTO  = 0,           /* XXXbe redundant w.r.t. id */
  96.     JSACC_PARENT = 1,           /* XXXbe redundant w.r.t. id */
  97.     JSACC_IMPORT = 2,           /* import foo.bar */
  98.     JSACC_WATCH  = 3,           /* a watchpoint on object foo for id 'bar' */
  99.     JSACC_READ   = 4,           /* a "get" of foo.bar */
  100.     JSACC_WRITE  = 8,           /* a "set" of foo.bar = baz */
  101.     JSACC_LIMIT
  102. } JSAccessMode;
  103.  
  104. #define JSACC_TYPEMASK          (JSACC_WRITE - 1)
  105.  
  106. /*
  107.  * This enum type is used to control the behavior of a JSObject property
  108.  * iterator function that has type JSNewEnumerate.
  109.  */
  110. typedef enum JSIterateOp {
  111.     JSENUMERATE_INIT,       /* Create new iterator state */
  112.     JSENUMERATE_NEXT,       /* Iterate once */
  113.     JSENUMERATE_DESTROY     /* Destroy iterator state */
  114. } JSIterateOp;
  115.  
  116. /* Struct typedefs. */
  117. typedef struct JSClass           JSClass;
  118. typedef struct JSExtendedClass   JSExtendedClass;
  119. typedef struct JSConstDoubleSpec JSConstDoubleSpec;
  120. typedef struct JSContext         JSContext;
  121. typedef struct JSErrorReport     JSErrorReport;
  122. typedef struct JSFunction        JSFunction;
  123. typedef struct JSFunctionSpec    JSFunctionSpec;
  124. typedef struct JSIdArray         JSIdArray;
  125. typedef struct JSProperty        JSProperty;
  126. typedef struct JSPropertySpec    JSPropertySpec;
  127. typedef struct JSObject          JSObject;
  128. typedef struct JSObjectMap       JSObjectMap;
  129. typedef struct JSObjectOps       JSObjectOps;
  130. typedef struct JSXMLObjectOps    JSXMLObjectOps;
  131. typedef struct JSRuntime         JSRuntime;
  132. typedef struct JSRuntime         JSTaskState;   /* XXX deprecated name */
  133. typedef struct JSScript          JSScript;
  134. typedef struct JSString          JSString;
  135. typedef struct JSXDRState        JSXDRState;
  136. typedef struct JSExceptionState  JSExceptionState;
  137. typedef struct JSLocaleCallbacks JSLocaleCallbacks;
  138.  
  139. /* JSClass (and JSObjectOps where appropriate) function pointer typedefs. */
  140.  
  141. /*
  142.  * Add, delete, get or set a property named by id in obj.  Note the jsval id
  143.  * type -- id may be a string (Unicode property identifier) or an int (element
  144.  * index).  The *vp out parameter, on success, is the new property value after
  145.  * an add, get, or set.  After a successful delete, *vp is JSVAL_FALSE iff
  146.  * obj[id] can't be deleted (because it's permanent).
  147.  */
  148. typedef JSBool
  149. (* JS_DLL_CALLBACK JSPropertyOp)(JSContext *cx, JSObject *obj, jsval id,
  150.                                  jsval *vp);
  151.  
  152. /*
  153.  * This function type is used for callbacks that enumerate the properties of
  154.  * a JSObject.  The behavior depends on the value of enum_op:
  155.  *
  156.  *  JSENUMERATE_INIT
  157.  *    A new, opaque iterator state should be allocated and stored in *statep.
  158.  *    (You can use PRIVATE_TO_JSVAL() to tag the pointer to be stored).
  159.  *
  160.  *    The number of properties that will be enumerated should be returned as
  161.  *    an integer jsval in *idp, if idp is non-null, and provided the number of
  162.  *    enumerable properties is known.  If idp is non-null and the number of
  163.  *    enumerable properties can't be computed in advance, *idp should be set
  164.  *    to JSVAL_ZERO.
  165.  *
  166.  *  JSENUMERATE_NEXT
  167.  *    A previously allocated opaque iterator state is passed in via statep.
  168.  *    Return the next jsid in the iteration using *idp.  The opaque iterator
  169.  *    state pointed at by statep is destroyed and *statep is set to JSVAL_NULL
  170.  *    if there are no properties left to enumerate.
  171.  *
  172.  *  JSENUMERATE_DESTROY
  173.  *    Destroy the opaque iterator state previously allocated in *statep by a
  174.  *    call to this function when enum_op was JSENUMERATE_INIT.
  175.  *
  176.  * The return value is used to indicate success, with a value of JS_FALSE
  177.  * indicating failure.
  178.  */
  179. typedef JSBool
  180. (* JS_DLL_CALLBACK JSNewEnumerateOp)(JSContext *cx, JSObject *obj,
  181.                                      JSIterateOp enum_op,
  182.                                      jsval *statep, jsid *idp);
  183.  
  184. /*
  185.  * The old-style JSClass.enumerate op should define all lazy properties not
  186.  * yet reflected in obj.
  187.  */
  188. typedef JSBool
  189. (* JS_DLL_CALLBACK JSEnumerateOp)(JSContext *cx, JSObject *obj);
  190.  
  191. /*
  192.  * Resolve a lazy property named by id in obj by defining it directly in obj.
  193.  * Lazy properties are those reflected from some peer native property space
  194.  * (e.g., the DOM attributes for a given node reflected as obj) on demand.
  195.  *
  196.  * JS looks for a property in an object, and if not found, tries to resolve
  197.  * the given id.  If resolve succeeds, the engine looks again in case resolve
  198.  * defined obj[id].  If no such property exists directly in obj, the process
  199.  * is repeated with obj's prototype, etc.
  200.  *
  201.  * NB: JSNewResolveOp provides a cheaper way to resolve lazy properties.
  202.  */
  203. typedef JSBool
  204. (* JS_DLL_CALLBACK JSResolveOp)(JSContext *cx, JSObject *obj, jsval id);
  205.  
  206. /*
  207.  * Like JSResolveOp, but flags provide contextual information as follows:
  208.  *
  209.  *  JSRESOLVE_QUALIFIED   a qualified property id: obj.id or obj[id], not id
  210.  *  JSRESOLVE_ASSIGNING   obj[id] is on the left-hand side of an assignment
  211.  *  JSRESOLVE_DETECTING   'if (o.p)...' or similar detection opcode sequence
  212.  *  JSRESOLVE_DECLARING   var, const, or function prolog declaration opcode
  213.  *  JSRESOLVE_CLASSNAME   class name used when constructing
  214.  *
  215.  * The *objp out parameter, on success, should be null to indicate that id
  216.  * was not resolved; and non-null, referring to obj or one of its prototypes,
  217.  * if id was resolved.
  218.  *
  219.  * This hook instead of JSResolveOp is called via the JSClass.resolve member
  220.  * if JSCLASS_NEW_RESOLVE is set in JSClass.flags.
  221.  *
  222.  * Setting JSCLASS_NEW_RESOLVE and JSCLASS_NEW_RESOLVE_GETS_START further
  223.  * extends this hook by passing in the starting object on the prototype chain
  224.  * via *objp.  Thus a resolve hook implementation may define the property id
  225.  * being resolved in the object in which the id was first sought, rather than
  226.  * in a prototype object whose class led to the resolve hook being called.
  227.  *
  228.  * When using JSCLASS_NEW_RESOLVE_GETS_START, the resolve hook must therefore
  229.  * null *objp to signify "not resolved".  With only JSCLASS_NEW_RESOLVE and no
  230.  * JSCLASS_NEW_RESOLVE_GETS_START, the hook can assume *objp is null on entry.
  231.  * This is not good practice, but enough existing hook implementations count
  232.  * on it that we can't break compatibility by passing the starting object in
  233.  * *objp without a new JSClass flag.
  234.  */
  235. typedef JSBool
  236. (* JS_DLL_CALLBACK JSNewResolveOp)(JSContext *cx, JSObject *obj, jsval id,
  237.                                    uintN flags, JSObject **objp);
  238.  
  239. /*
  240.  * Convert obj to the given type, returning true with the resulting value in
  241.  * *vp on success, and returning false on error or exception.
  242.  */
  243. typedef JSBool
  244. (* JS_DLL_CALLBACK JSConvertOp)(JSContext *cx, JSObject *obj, JSType type,
  245.                                 jsval *vp);
  246.  
  247. /*
  248.  * Finalize obj, which the garbage collector has determined to be unreachable
  249.  * from other live objects or from GC roots.  Obviously, finalizers must never
  250.  * store a reference to obj.
  251.  */
  252. typedef void
  253. (* JS_DLL_CALLBACK JSFinalizeOp)(JSContext *cx, JSObject *obj);
  254.  
  255. /*
  256.  * Used by JS_AddExternalStringFinalizer and JS_RemoveExternalStringFinalizer
  257.  * to extend and reduce the set of string types finalized by the GC.
  258.  */
  259. typedef void
  260. (* JS_DLL_CALLBACK JSStringFinalizeOp)(JSContext *cx, JSString *str);
  261.  
  262. /*
  263.  * The signature for JSClass.getObjectOps, used by JS_NewObject's internals
  264.  * to discover the set of high-level object operations to use for new objects
  265.  * of the given class.  All native objects have a JSClass, which is stored as
  266.  * a private (int-tagged) pointer in obj->slots[JSSLOT_CLASS].  In contrast,
  267.  * all native and host objects have a JSObjectMap at obj->map, which may be
  268.  * shared among a number of objects, and which contains the JSObjectOps *ops
  269.  * pointer used to dispatch object operations from API calls.
  270.  *
  271.  * Thus JSClass (which pre-dates JSObjectOps in the API) provides a low-level
  272.  * interface to class-specific code and data, while JSObjectOps allows for a
  273.  * higher level of operation, which does not use the object's class except to
  274.  * find the class's JSObjectOps struct, by calling clasp->getObjectOps, and to
  275.  * finalize the object.
  276.  *
  277.  * If this seems backwards, that's because it is!  API compatibility requires
  278.  * a JSClass *clasp parameter to JS_NewObject, etc.  Most host objects do not
  279.  * need to implement the larger JSObjectOps, and can share the common JSScope
  280.  * code and data used by the native (js_ObjectOps, see jsobj.c) ops.
  281.  *
  282.  * Further extension to preserve API compatibility: if this function returns
  283.  * a pointer to JSXMLObjectOps.base, not to JSObjectOps, then the engine calls
  284.  * extended hooks needed for E4X.
  285.  */
  286. typedef JSObjectOps *
  287. (* JS_DLL_CALLBACK JSGetObjectOps)(JSContext *cx, JSClass *clasp);
  288.  
  289. /*
  290.  * JSClass.checkAccess type: check whether obj[id] may be accessed per mode,
  291.  * returning false on error/exception, true on success with obj[id]'s last-got
  292.  * value in *vp, and its attributes in *attrsp.  As for JSPropertyOp above, id
  293.  * is either a string or an int jsval.
  294.  *
  295.  * See JSCheckAccessIdOp, below, for the JSObjectOps counterpart, which takes
  296.  * a jsid (a tagged int or aligned, unique identifier pointer) rather than a
  297.  * jsval.  The native js_ObjectOps.checkAccess simply forwards to the object's
  298.  * clasp->checkAccess, so that both JSClass and JSObjectOps implementors may
  299.  * specialize access checks.
  300.  */
  301. typedef JSBool
  302. (* JS_DLL_CALLBACK JSCheckAccessOp)(JSContext *cx, JSObject *obj, jsval id,
  303.                                     JSAccessMode mode, jsval *vp);
  304.  
  305. /*
  306.  * Encode or decode an object, given an XDR state record representing external
  307.  * data.  See jsxdrapi.h.
  308.  */
  309. typedef JSBool
  310. (* JS_DLL_CALLBACK JSXDRObjectOp)(JSXDRState *xdr, JSObject **objp);
  311.  
  312. /*
  313.  * Check whether v is an instance of obj.  Return false on error or exception,
  314.  * true on success with JS_TRUE in *bp if v is an instance of obj, JS_FALSE in
  315.  * *bp otherwise.
  316.  */
  317. typedef JSBool
  318. (* JS_DLL_CALLBACK JSHasInstanceOp)(JSContext *cx, JSObject *obj, jsval v,
  319.                                     JSBool *bp);
  320.  
  321. /*
  322.  * Function type for JSClass.mark and JSObjectOps.mark, called from the GC to
  323.  * scan live GC-things reachable from obj's private data structure.  For each
  324.  * such thing, a mark implementation must call
  325.  *
  326.  *    JS_MarkGCThing(cx, thing, name, arg);
  327.  *
  328.  * The trailing name and arg parameters are used for GC_MARK_DEBUG-mode heap
  329.  * dumping and ref-path tracing.  The mark function should pass a (typically
  330.  * literal) string naming the private data member for name, and it must pass
  331.  * the opaque arg parameter through from its caller.
  332.  *
  333.  * For the JSObjectOps.mark hook, the return value is the number of slots at
  334.  * obj->slots to scan.  For JSClass.mark, the return value is ignored.
  335.  *
  336.  * NB: JSMarkOp implementations cannot allocate new GC-things (JS_NewObject
  337.  * called from a mark function will fail silently, e.g.).
  338.  */
  339. typedef uint32
  340. (* JS_DLL_CALLBACK JSMarkOp)(JSContext *cx, JSObject *obj, void *arg);
  341.  
  342. /*
  343.  * The optional JSClass.reserveSlots hook allows a class to make computed
  344.  * per-instance object slots reservations, in addition to or instead of using
  345.  * JSCLASS_HAS_RESERVED_SLOTS(n) in the JSClass.flags initializer to reserve
  346.  * a constant-per-class number of slots.  Implementations of this hook should
  347.  * return the number of slots to reserve, not including any reserved by using
  348.  * JSCLASS_HAS_RESERVED_SLOTS(n) in JSClass.flags.
  349.  *
  350.  * NB: called with obj locked by the JSObjectOps-specific mutual exclusion
  351.  * mechanism appropriate for obj, so don't nest other operations that might
  352.  * also lock obj.
  353.  */
  354. typedef uint32
  355. (* JS_DLL_CALLBACK JSReserveSlotsOp)(JSContext *cx, JSObject *obj);
  356.  
  357. /* JSObjectOps function pointer typedefs. */
  358.  
  359. /*
  360.  * Create a new subclass of JSObjectMap (see jsobj.h), with the nrefs and ops
  361.  * members initialized from the same-named parameters, and with the nslots and
  362.  * freeslot members initialized according to ops and clasp.  Return null on
  363.  * error, non-null on success.
  364.  *
  365.  * JSObjectMaps are reference-counted by generic code in the engine.  Usually,
  366.  * the nrefs parameter to JSObjectOps.newObjectMap will be 1, to count the ref
  367.  * returned to the caller on success.  After a successful construction, some
  368.  * number of js_HoldObjectMap and js_DropObjectMap calls ensue.  When nrefs
  369.  * reaches 0 due to a js_DropObjectMap call, JSObjectOps.destroyObjectMap will
  370.  * be called to dispose of the map.
  371.  */
  372. typedef JSObjectMap *
  373. (* JS_DLL_CALLBACK JSNewObjectMapOp)(JSContext *cx, jsrefcount nrefs,
  374.                                      JSObjectOps *ops, JSClass *clasp,
  375.                                      JSObject *obj);
  376.  
  377. /*
  378.  * Generic type for an infallible JSObjectMap operation, used currently by
  379.  * JSObjectOps.destroyObjectMap.
  380.  */
  381. typedef void
  382. (* JS_DLL_CALLBACK JSObjectMapOp)(JSContext *cx, JSObjectMap *map);
  383.  
  384. /*
  385.  * Look for id in obj and its prototype chain, returning false on error or
  386.  * exception, true on success.  On success, return null in *propp if id was
  387.  * not found.  If id was found, return the first object searching from obj
  388.  * along its prototype chain in which id names a direct property in *objp, and
  389.  * return a non-null, opaque property pointer in *propp.
  390.  *
  391.  * If JSLookupPropOp succeeds and returns with *propp non-null, that pointer
  392.  * may be passed as the prop parameter to a JSAttributesOp, as a short-cut
  393.  * that bypasses id re-lookup.  In any case, a non-null *propp result after a
  394.  * successful lookup must be dropped via JSObjectOps.dropProperty.
  395.  *
  396.  * NB: successful return with non-null *propp means the implementation may
  397.  * have locked *objp and added a reference count associated with *propp, so
  398.  * callers should not risk deadlock by nesting or interleaving other lookups
  399.  * or any obj-bearing ops before dropping *propp.
  400.  */
  401. typedef JSBool
  402. (* JS_DLL_CALLBACK JSLookupPropOp)(JSContext *cx, JSObject *obj, jsid id,
  403.                                    JSObject **objp, JSProperty **propp);
  404.  
  405. /*
  406.  * Define obj[id], a direct property of obj named id, having the given initial
  407.  * value, with the specified getter, setter, and attributes.  If the propp out
  408.  * param is non-null, *propp on successful return contains an opaque property
  409.  * pointer usable as a speedup hint with JSAttributesOp.  But note that propp
  410.  * may be null, indicating that the caller is not interested in recovering an
  411.  * opaque pointer to the newly-defined property.
  412.  *
  413.  * If propp is non-null and JSDefinePropOp succeeds, its caller must be sure
  414.  * to drop *propp using JSObjectOps.dropProperty in short order, just as with
  415.  * JSLookupPropOp.
  416.  */
  417. typedef JSBool
  418. (* JS_DLL_CALLBACK JSDefinePropOp)(JSContext *cx, JSObject *obj,
  419.                                    jsid id, jsval value,
  420.                                    JSPropertyOp getter, JSPropertyOp setter,
  421.                                    uintN attrs, JSProperty **propp);
  422.  
  423. /*
  424.  * Get, set, or delete obj[id], returning false on error or exception, true
  425.  * on success.  If getting or setting, the new value is returned in *vp on
  426.  * success.  If deleting without error, *vp will be JSVAL_FALSE if obj[id] is
  427.  * permanent, and JSVAL_TRUE if id named a direct property of obj that was in
  428.  * fact deleted, or if id names no direct property of obj (id could name a
  429.  * prototype property, or no property in obj or its prototype chain).
  430.  */
  431. typedef JSBool
  432. (* JS_DLL_CALLBACK JSPropertyIdOp)(JSContext *cx, JSObject *obj, jsid id,
  433.                                    jsval *vp);
  434.  
  435. /*
  436.  * Get or set attributes of the property obj[id].  Return false on error or
  437.  * exception, true with current attributes in *attrsp.  If prop is non-null,
  438.  * it must come from the *propp out parameter of a prior JSDefinePropOp or
  439.  * JSLookupPropOp call.
  440.  */
  441. typedef JSBool
  442. (* JS_DLL_CALLBACK JSAttributesOp)(JSContext *cx, JSObject *obj, jsid id,
  443.                                    JSProperty *prop, uintN *attrsp);
  444.  
  445. /*
  446.  * JSObjectOps.checkAccess type: check whether obj[id] may be accessed per
  447.  * mode, returning false on error/exception, true on success with obj[id]'s
  448.  * last-got value in *vp, and its attributes in *attrsp.
  449.  */
  450. typedef JSBool
  451. (* JS_DLL_CALLBACK JSCheckAccessIdOp)(JSContext *cx, JSObject *obj, jsid id,
  452.                                       JSAccessMode mode, jsval *vp,
  453.                                       uintN *attrsp);
  454.  
  455. /*
  456.  * A generic type for functions mapping an object to another object, or null
  457.  * if an error or exception was thrown on cx.  Used by JSObjectOps.thisObject
  458.  * at present.
  459.  */
  460. typedef JSObject *
  461. (* JS_DLL_CALLBACK JSObjectOp)(JSContext *cx, JSObject *obj);
  462.  
  463. /*
  464.  * A generic type for functions taking a context, object, and property, with
  465.  * no return value.  Used by JSObjectOps.dropProperty currently (see above,
  466.  * JSDefinePropOp and JSLookupPropOp, for the object-locking protocol in which
  467.  * dropProperty participates).
  468.  */
  469. typedef void
  470. (* JS_DLL_CALLBACK JSPropertyRefOp)(JSContext *cx, JSObject *obj,
  471.                                     JSProperty *prop);
  472.  
  473. /*
  474.  * Function type for JSObjectOps.setProto and JSObjectOps.setParent.  These
  475.  * hooks must check for cycles without deadlocking, and otherwise take special
  476.  * steps.  See jsobj.c, js_SetProtoOrParent, for an example.
  477.  */
  478. typedef JSBool
  479. (* JS_DLL_CALLBACK JSSetObjectSlotOp)(JSContext *cx, JSObject *obj,
  480.                                       uint32 slot, JSObject *pobj);
  481.  
  482. /*
  483.  * Get and set a required slot, one that should already have been allocated.
  484.  * These operations are infallible, so required slots must be pre-allocated,
  485.  * or implementations must suppress out-of-memory errors.  The native ops
  486.  * (js_ObjectOps, see jsobj.c) access slots reserved by including a call to
  487.  * the JSCLASS_HAS_RESERVED_SLOTS(n) macro in the JSClass.flags initializer.
  488.  *
  489.  * NB: the slot parameter is a zero-based index into obj->slots[], unlike the
  490.  * index parameter to the JS_GetReservedSlot and JS_SetReservedSlot API entry
  491.  * points, which is a zero-based index into the JSCLASS_RESERVED_SLOTS(clasp)
  492.  * reserved slots that come after the initial well-known slots: proto, parent,
  493.  * class, and optionally, the private data slot.
  494.  */
  495. typedef jsval
  496. (* JS_DLL_CALLBACK JSGetRequiredSlotOp)(JSContext *cx, JSObject *obj,
  497.                                         uint32 slot);
  498.  
  499. typedef JSBool
  500. (* JS_DLL_CALLBACK JSSetRequiredSlotOp)(JSContext *cx, JSObject *obj,
  501.                                         uint32 slot, jsval v);
  502.  
  503. typedef JSObject *
  504. (* JS_DLL_CALLBACK JSGetMethodOp)(JSContext *cx, JSObject *obj, jsid id,
  505.                                   jsval *vp);
  506.  
  507. typedef JSBool
  508. (* JS_DLL_CALLBACK JSSetMethodOp)(JSContext *cx, JSObject *obj, jsid id,
  509.                                   jsval *vp);
  510.  
  511. typedef JSBool
  512. (* JS_DLL_CALLBACK JSEnumerateValuesOp)(JSContext *cx, JSObject *obj,
  513.                                         JSIterateOp enum_op,
  514.                                         jsval *statep, jsid *idp, jsval *vp);
  515.  
  516. typedef JSBool
  517. (* JS_DLL_CALLBACK JSEqualityOp)(JSContext *cx, JSObject *obj, jsval v,
  518.                                  JSBool *bp);
  519.  
  520. typedef JSBool
  521. (* JS_DLL_CALLBACK JSConcatenateOp)(JSContext *cx, JSObject *obj, jsval v,
  522.                                     jsval *vp);
  523.  
  524. /* Typedef for native functions called by the JS VM. */
  525.  
  526. typedef JSBool
  527. (* JS_DLL_CALLBACK JSNative)(JSContext *cx, JSObject *obj, uintN argc,
  528.                              jsval *argv, jsval *rval);
  529.  
  530. /* Callbacks and their arguments. */
  531.  
  532. typedef enum JSGCStatus {
  533.     JSGC_BEGIN,
  534.     JSGC_END,
  535.     JSGC_MARK_END,
  536.     JSGC_FINALIZE_END
  537. } JSGCStatus;
  538.  
  539. typedef JSBool
  540. (* JS_DLL_CALLBACK JSGCCallback)(JSContext *cx, JSGCStatus status);
  541.  
  542. typedef JSBool
  543. (* JS_DLL_CALLBACK JSBranchCallback)(JSContext *cx, JSScript *script);
  544.  
  545. typedef void
  546. (* JS_DLL_CALLBACK JSErrorReporter)(JSContext *cx, const char *message,
  547.                                     JSErrorReport *report);
  548.  
  549. typedef struct JSErrorFormatString {
  550.     const char *format;
  551.     uintN argCount;
  552. } JSErrorFormatString;
  553.  
  554. typedef const JSErrorFormatString *
  555. (* JS_DLL_CALLBACK JSErrorCallback)(void *userRef, const char *locale,
  556.                                     const uintN errorNumber);
  557.  
  558. #ifdef va_start
  559. #define JS_ARGUMENT_FORMATTER_DEFINED 1
  560.  
  561. typedef JSBool
  562. (* JS_DLL_CALLBACK JSArgumentFormatter)(JSContext *cx, const char *format,
  563.                                         JSBool fromJS, jsval **vpp,
  564.                                         va_list *app);
  565. #endif
  566.  
  567. typedef JSBool
  568. (* JS_DLL_CALLBACK JSLocaleToUpperCase)(JSContext *cx, JSString *src,
  569.                                         jsval *rval);
  570.  
  571. typedef JSBool
  572. (* JS_DLL_CALLBACK JSLocaleToLowerCase)(JSContext *cx, JSString *src,
  573.                                         jsval *rval);
  574.  
  575. typedef JSBool
  576. (* JS_DLL_CALLBACK JSLocaleCompare)(JSContext *cx,
  577.                                     JSString *src1, JSString *src2,
  578.                                     jsval *rval);
  579.  
  580. typedef JSBool
  581. (* JS_DLL_CALLBACK JSLocaleToUnicode)(JSContext *cx, char *src, jsval *rval);
  582.  
  583. /*
  584.  * Security protocol types.
  585.  */
  586. typedef struct JSPrincipals JSPrincipals;
  587.  
  588. /*
  589.  * XDR-encode or -decode a principals instance, based on whether xdr->mode is
  590.  * JSXDR_ENCODE, in which case *principalsp should be encoded; or JSXDR_DECODE,
  591.  * in which case implementations must return a held (via JSPRINCIPALS_HOLD),
  592.  * non-null *principalsp out parameter.  Return true on success, false on any
  593.  * error, which the implementation must have reported.
  594.  */
  595. typedef JSBool
  596. (* JS_DLL_CALLBACK JSPrincipalsTranscoder)(JSXDRState *xdr,
  597.                                            JSPrincipals **principalsp);
  598.  
  599. /*
  600.  * Return a weak reference to the principals associated with obj, possibly via
  601.  * the immutable parent chain leading from obj to a top-level container (e.g.,
  602.  * a window object in the DOM level 0).  If there are no principals associated
  603.  * with obj, return null.  Therefore null does not mean an error was reported;
  604.  * in no event should an error be reported or an exception be thrown by this
  605.  * callback's implementation.
  606.  */
  607. typedef JSPrincipals *
  608. (* JS_DLL_CALLBACK JSObjectPrincipalsFinder)(JSContext *cx, JSObject *obj);
  609.  
  610. JS_END_EXTERN_C
  611.  
  612. #endif /* jspubtd_h___ */
  613.